package com.ktjiaotu.action.action02;

import com.ktjiaotu.action.action02.error.ValidationException;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * @Author: DABINGCHNEGJIAO
 * @CreateTime: 2025-06-06
 * @Description:
 * @Version: 1.0
 */
public class ValidationInvocationHandler implements InvocationHandler {
    private final Object target;

    public ValidationInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //获取这个对象接口的所有方法
        Method[] methods = target.getClass().getInterfaces()[0].getMethods();
        for (Method m : methods) {
            //判断方法名和参数个数与执行的方法是否相同
            if (m.getName().equals(method.getName()) && m.getParameterCount() == args.length) {
                //获取这个方法的所有参数
                Parameter[] parameters = m.getParameters();
                for (int i = 0; i < parameters.length; i++) {
                    //判断参数是否有@Validate注解
                    if (parameters[i].isAnnotationPresent(Validate.class)) {
                        //有的话获取这个参数的@Validate注解对象 和 这个参数的值
                        Validate validate = parameters[i].getAnnotation(Validate.class);
                        Object arg = args[i];

                        //是否开启null判断
                        if (validate.notEmpty()) {
                            //判断这个参数@Validate注解的条件是否开启,如果开启则判断这个参数的值是否符合条件
                            if (validate.notEmpty() && arg == null) {
                                throw new ValidationException("参数不能是空");
                            }
                        }
                        if (arg instanceof Double) {
                            Double value = (Double) arg;
                            //先判断是否为正或者负无穷大(也就是说我有没有给参数加注解的时候提供值,有提供说明修改了默认值也就不是无穷大了之后->),再判断参数是否大于或小于注解的值
                            if (!Double.isInfinite(validate.minValue()) && value < validate.minValue()) {
                                throw new ValidationException("参数不能小于" + validate.minValue());
                            }
                            if (!Double.isInfinite(validate.maxValue()) && value > validate.maxValue()) {
                                throw new ValidationException("参数不能大于" + validate.maxValue());
                            }
                        } else {
                            throw new IllegalArgumentException("不支持的参数类型" + arg.getClass().getName());
                        }
                    }
                }
            }
        }
        return method.invoke(target, args);
    }
}
